Auto Insurance Claims Data¶
Problem Statement¶
A car insurance claim is a process wherein an insured asks the car insurance company to compensate him/her for the damages that are sustained by his/her car after an accident. Or at times, it is when the insured asks the insurance company to represent him/her or intervene on his/her behalf when the insured is responsible for any unintentional damages caused to a third-party. Since one pays car insurance premium, it is one’s right to make a claim when he/she is involved in an accident
we are required to build a model that will predict if the claims that were registered are fraud or not using the given data set.
Importing All the library¶
In [1]:
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.preprocessing import LabelEncoder
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression,Ridge,Lasso
from sklearn.metrics import mean_squared_error,mean_absolute_error,r2_score
from statsmodels.formula.api import ols
from sklearn.ensemble import RandomForestClassifier
from sklearn.tree import DecisionTreeRegressor
from sklearn.svm import SVR
from sklearn.decomposition import PCA
import xgboost as xgb
from IPython.display import Image
from sklearn.model_selection import train_test_split
from IPython.display import Image
import plotly.express as px
import plotly.graph_objects as go
import os
from imblearn.over_sampling import RandomOverSampler
from imblearn.combine import SMOTETomek
from sklearn.metrics import confusion_matrix,accuracy_score,classification_report
In [2]:
pd.set_option('display.max_row', 100000)
pd.set_option('display.max_columns',500000)
In [3]:
os.getcwd()
Out[3]:
Reading The files¶
In [76]:
dt_insurance=pd.read_csv('insurance_claims.csv')
In [5]:
dt_insurance.head()
Out[5]:
In [6]:
dt_insurance.columns
Out[6]:
In [7]:
dt_insurance.shape
Out[7]:
In [8]:
corr_matrix=dt_insurance.corr()
In [9]:
corr_matrix
Out[9]:
In [10]:
plt.figure(figsize=(20,15))
sns.heatmap(dt_insurance.corr(),annot=True,cmap='coolwarm')
Out[10]:
Data Visualization¶
I will plot all the independent variable with respect to fraud reported as yes¶
In [70]:
dt_insurance['collision_type'].replace({'?':'None'},inplace=True)
In [71]:
dt_insurance=dt_insurance[dt_insurance['fraud_reported']=='Y']
In [12]:
df_polstate=dt_insurance.groupby('fraud_reported')['policy_state'].value_counts(normalize=True)
df_polstate = df_polstate.mul(100).rename('Percent').reset_index()
In [13]:
df_polstate['Percent']=df_polstate['Percent'].round(decimals=2)
In [14]:
df_polstate.head()
Out[14]:
In [15]:
px.bar(df_polstate, x='fraud_reported', y='Percent', color='policy_state',title="Fraud reported as yes w.r.t State"
,barmode='group', text='Percent')
Observation¶
- This graph shows the precentage of fraud reported as yes w.r.t State
In [16]:
df_sex=dt_insurance.groupby('fraud_reported')['insured_sex'].value_counts(normalize=True)
df_sex = df_sex.mul(100).rename('Percent').reset_index()
df_sex['Percent']=df_sex['Percent'].round(decimals=2)
df_sex.head(10)
Out[16]:
In [17]:
px.bar(df_sex, x='fraud_reported', y='Percent', color='insured_sex', title="Fraud reported as yes w.r.t Insured sex"
,barmode='group', text='Percent')
Observation¶
- This graph shows the precentage of fraud reported as yes w.r.t Insured Sex
- percentage of fraud w.r.t to sex has no such difference
In [18]:
df_inci=dt_insurance.groupby('fraud_reported')['incident_type'].value_counts(normalize=True)
df_inci = df_inci.mul(100).rename('Percent').reset_index()
df_inci['Percent']=df_inci['Percent'].round(decimals=2)
df_inci.head(10)
Out[18]:
In [19]:
px.bar(df_inci, x='fraud_reported', y='Percent', color='incident_type', title="Fraud reported as yes w.r.t Incedent type"
,barmode='group', text='Percent')
Observation¶
- from the graph we can clearly see that for incident type like 'Single vehicle Collision','Multi Vehicle collision' has much higher percentage of fraud reported
In [72]:
df_colli=dt_insurance.groupby('fraud_reported')['collision_type'].value_counts(normalize=True)
df_colli = df_colli.mul(100).rename('Percent').reset_index()
df_colli['Percent']=df_colli['Percent'].round(decimals=2)
df_colli.head(10)
Out[72]:
In [73]:
px.bar(df_colli, x='fraud_reported', y='Percent', color='collision_type', title="Fraud reported as yes w.r.t Collison type",
barmode='group', text='Percent')
Observation¶
- from the graph we can clearly see that for Collision type fraud reported as yes has no such variance in the percentage
In [22]:
df_edu=dt_insurance.groupby('fraud_reported')['insured_education_level'].value_counts(normalize=True)
df_edu = df_edu.mul(100).rename('Percent').reset_index()
df_edu['Percent']=df_edu['Percent'].round(decimals=2)
df_edu.head(10)
Out[22]:
In [23]:
px.bar(df_edu, x='fraud_reported', y='Percent', color='insured_education_level', title="Fraud reported as yes w.r.t insured education",
barmode='group', text='Percent')
Observation¶
- from the graph we can clearly see that for Education level fraud reported as yes has no such variance in the percentage
In [26]:
df_hobby=dt_insurance.groupby('fraud_reported')['insured_hobbies'].value_counts(normalize=True)
df_hobby = df_hobby.mul(100).rename('Percent').reset_index()
df_hobby['Percent']=df_hobby['Percent'].round(decimals=2)
df_hobby.head(10)
Out[26]:
In [27]:
px.bar(df_hobby, x='fraud_reported', y='Percent', color='insured_hobbies', title="Fraud reported as yes w.r.t insured hobbies",
barmode='group', text='Percent')
Observation¶
- From the graph I can conclude that insurerer with hobbies like chess,cross-fit has much higher percentage of making fraud claim w.r.t to other hobbies
In [32]:
df_city=dt_insurance.groupby('fraud_reported')['incident_city'].value_counts(normalize=True)
df_city = df_city.mul(100).rename('Percent').reset_index()
df_city['Percent']=df_city['Percent'].round(decimals=2)
df_city.head(10)
Out[32]:
In [33]:
px.bar(df_city, x='fraud_reported', y='Percent', color='incident_city', title="Fraud reported as yes w.r.t Incident City"
,barmode='group', text='Percent')
Observation¶
- Fraudulent activites are independent of city
Feature Engeenering¶
In [223]:
dt_insurance.dtypes
Out[223]:
In [195]:
dt_insurance['incident_date']=pd.to_datetime(dt_insurance['incident_date'].astype('datetime64[ns]'),format='%y%m%d')
dt_insurance['policy_bind_date']=pd.to_datetime(dt_insurance['policy_bind_date'].astype('datetime64[ns]'),format='%y%m%d')
dt_insurance['incedent_month']=pd.DatetimeIndex(dt_insurance['incident_date']).month
dt_insurance['incedent_year']=pd.DatetimeIndex(dt_insurance['incident_date']).year
dt_insurance.drop(['policy_bind_date','incident_date'],axis=1,inplace=True)
In [194]:
dt_insurance=pd.read_csv('insurance_claims.csv')
I will use on-hot encodding method to change the categorical variable to numeric variable for Property Damage paramter¶
In [363]:
dt_insurance.property_damage.unique()
Out[363]:
In [227]:
xyz=pd.get_dummies(dt_insurance['property_damage'],drop_first=True)
dt_insurance=pd.concat([dt_insurance,xyz],axis=1)
dt_insurance.drop('property_damage',axis=1,inplace=True)
dt_insurance.head()
Out[227]:
I will use value count method for police report availabe variable¶
In [229]:
insured_map=dt_insurance['police_report_available'].value_counts().to_dict()
insured_map
dt_insurance['police_report_available']=dt_insurance['police_report_available'].map(insured_map)
dt_insurance.head()
Out[229]:
Feature Selection¶
In [231]:
X=dt_insurance.drop('fraud_reported',axis=1)
y=dt_insurance['fraud_reported']
In [232]:
X.head()
Out[232]:
In [623]:
y.head()
Out[623]:
I will use K best library to select top 20 attribute from the data set which are highly co-related to the output variable¶
In [233]:
from sklearn.feature_selection import SelectKBest,f_classif
from sklearn.feature_selection import chi2
In [234]:
ordered_rank_features=SelectKBest(f_classif,k=20)
ordered_feature=ordered_rank_features.fit(X,dt_insurance['fraud_reported'])
In [235]:
dfscores=pd.DataFrame(ordered_feature.scores_,columns=["Score"])
dfcolumns=pd.DataFrame(X.columns)
In [236]:
features_rank=pd.concat([dfcolumns,dfscores],axis=1)
In [237]:
features_rank.columns=['Features','Score']
features_rank
Out[237]:
In [364]:
features_rank.nlargest(20,'Score')
Out[364]:
Now I will create a dataframe with these 20 variables and apply Logistic Regression and Random Forest Classifier¶
In [248]:
dt_ins_ver=dt_insurance[["Minor Damage","Total Loss","vehicle_claim",
"total_claim_amount","insured_hobbies","property_claim",
"Trivial Damage","Vehicle Theft",
"Parked Car","Rear Collision","injury_claim","NO",
"Single Vehicle Collision",
"umbrella_limit",
"number_of_vehicles_involved","witnesses",
"incident_state","Front Collision","auto_model","bodily_injuries","fraud_reported"]].copy()
In [249]:
dt_ins_ver.head()
Out[249]:
Before applying any algorithm I am checking that the data set is imbalanced or not¶
In [250]:
plt.figure(figsize=(8,8))
sns.countplot('fraud_reported',data=dt_ins_ver)
plt.show()
In [251]:
dt_ins_ver.fraud_reported.value_counts()
Out[251]:
In [252]:
x=dt_ins_ver.drop('fraud_reported',axis=1)
y=dt_ins_ver['fraud_reported']
In [253]:
x.shape,y.shape
Out[253]:
In order to handle imbalanced data set problem SMOTETomek library is used¶
In [254]:
smk = SMOTETomek(random_state=42)
X_res,y_res=smk.fit_sample(x,y)
Dividing the data in train test split¶
In [255]:
x_train,x_test,y_train,y_test=train_test_split(X_res,y_res,test_size=0.3,random_state=42)
In [256]:
x_train.shape,y_train.shape,x_test.shape,y_test.shape
Out[256]:
Applying LogisticRegression¶
In [257]:
log_reg=LogisticRegression()
log_reg.fit(x_train,y_train)
log_pred=log_reg.predict(x_test)
In [258]:
cm1=confusion_matrix(y_test,log_pred)
sns.heatmap(cm1,annot=True,fmt='d')
Out[258]:
- In this plot X-axis indicate output of the data set and Y-axis indicate output of the model
In [259]:
print(accuracy_score(y_test,log_pred))
print(classification_report(y_test,log_pred))
Applying RandomForestClassifier¶
In [260]:
model_rand=RandomForestClassifier()
model_rand.fit(x_train,y_train)
model_rand_test=model_rand.predict(x_test)
In [261]:
cm1=confusion_matrix(y_test,model_rand_test)
sns.heatmap(cm1,annot=True,fmt='d')
Out[261]:
- In this plot X-axis indicate output of the data set and Y-axis indicate output of the model
In [366]:
print('Accuracy Score:',accuracy_score(y_test,model_rand_test))
print(classification_report(y_test,model_rand_test))
Observation¶
Random Forest is giving better accuracy then Logistic Regression with 20 parameter
Now we will apply the same process using 25 variable and 15 Variable¶
Observation¶
- For Random Forest Accuracy got decresed when I am taking 25 variable for model building
- For Random Forest Accuracy got reamins almost same when I am taking 15 and 20 variable
Trying to improve the model by applying hyper parameter tuning¶
In [310]:
from sklearn.model_selection import GridSearchCV
In [311]:
model_params = {
'n_estimators': [50, 150, 250],
'max_features': ['sqrt', 0.25, 0.5, 0.75, 1.0],
'min_samples_split': [2, 4, 6]
}
In [312]:
rf_model = RandomForestClassifier(random_state=1)
clf = GridSearchCV(rf_model, model_params, cv=5)
model = clf.fit(x_train,y_train)
In [314]:
grid_predict=model.predict(x_test)
In [315]:
cm1=confusion_matrix(y_test,grid_predict)
sns.heatmap(cm1,annot=True,fmt='d')
Out[315]:
- In this plot X-axis indicate output of the data set and Y-axis indicate output of the model
In [316]:
print(accuracy_score(y_test,grid_predict))
print(classification_report(y_test,grid_predict))
Observation¶
- For Random Forest Accuracy got increased a bit when I apply hyper parameter technique
Conclution¶
- After applying hyper parameter tuning I got the best accuracy of 88% for this dataset
- After applying K-best method I can conclude that following variables can be used to detect a fraudulant claim with 88% accuracy
- incident_severity, vehicle_claim, total_claim_amount, property_claim, incident_type, umbrella_limit, auto_model, incident_state, insured_hobbies, collision_type, bodily_injuries
In [ ]: